fix(semantic): bootstrap-complete archives a reopened replayed turn without duplicating it - #1391

Fixes #1290.

Plan: docs/plans/2026-09-27-semantic-history-bootstrap-dedupe.md.

Problem

The bootstrap-complete reconciler in useIpcSubscriptions.ts archived a still-open replayed turn with a raw [...history, row] append. A replayed turn T that was already in history could reopen as currentTurn, and the ledger hides that copy while T is live. Bootstrap-complete then appended T a second time. The result was two history rows with one turnId, repeated sem:T:i candidate ids, and duplicate semantic-block:T:i React keys.

What merges

The reconciler archives through a new archiveReplayedTurn helper in session-runtime/semantic/helpers.ts:

• T not archived yet: the helper appends it (via appendSemanticHistory).
• T already archived: the helper stores ONE row, a field-wise monotonic merge of the archived copy and the replay copy:
  • strings: the replay's value wins only when it extends the archived value (it starts with the archived value and is longer). Otherwise the archived value stays. This also keeps an archived status: 'completed' against a reopened, longer 'in_progress'.
  • plain objects (the turn, blocks, each block, lookups, usage): merged key by key.
  • arrays of primitives (blockOrder, the lookup id lists): unioned.
  • lifecycle fields take the MORE advanced value from either copy: status ranks pending < in_progress < terminal (two different terminal values, or an unknown value, keep the archived one); messagePhase ranks commentary < final_answer; booleans OR (finalized, inputJsonValid only ever become true). This protects a completed archive from a reopened replay AND lets a replay complete a block or tool the archive saw pending (review a, round 4).
  • a tool result is one unit (review a round 5, steering q95): resultContent, resultIsError, resultAt and the tool's lookup state (toolCallsById[id], and its membership in resolvedToolUseIds / erroredToolUseIds) all come from the copy with the LATER resultAt, and from the replay on a tie. Field by field, an archived error followed by a corrected result painted the success red, because the live reducer lets a later result clear the error, so no single result field is monotonic.
  • derived lists: task.inProgressToolUseIds is recomputed after the merge (the union minus every resolved/errored id). activeToolNames keeps only names both copies agree on.
  • everything else (numbers, and arrays of objects such as the task checklist): the archived value is kept.

Invariant: every archived string survives at its path, either unchanged or extended, and every archived block index and id stays. No lifecycle field moves backwards, and none is held back when either copy has progressed. The ledger paints only from these fields, so a field visible before bootstrap-complete cannot vanish. Content the replay added, such as a new block or longer text, is kept too.

Why a merge and not a proxy: reviewer A rejected three "does the replay cover the archive?" proxies in rounds 1–3:

• turn-text length missed empty blocks;
• block count missed an empty block at the same index;
• a content-size total missed reasoningSummary, and let unpainted turn text outweigh a missing answer block.

A merge doesn't have to judge which copy is richer.

Scope: live fold paths are unchanged. There, a newer copy of a turn stays authoritative (appendSemanticHistory replace).

Tests

• archiveReplayedTurn.test.ts: 15 cases. Each feeds the helper's output through a real renderer function (createLedgerInputAdapter() for painted text, groupSemanticActivity for tool activity). The cases:
  • both round-3 sequences from reviewer A (Codex reasoningSummary, and longer turn text vs an empty answer block);
  • rounds 1 and 2;
  • mixed progress: archived block 0 plus a new replay block 1;
  • an archived block the replay has not re-emitted;
  • the status-length trap;
  • replay-extends-archive;
  • round 5: reviewer a's corrected-result sequence (error at t=2, success at t=3, including the error→completed lookup status), the archived result being later, and a tie;
  • round 4: forward completion (Codex status, Claude finalized), and a Read tool the replay resolved, plus the reverse, checked through the real groupSemanticActivity (not running) and the recomputed in-progress lists.
• Fail-first: at f7b65430, 4 of the round-3 cases fail (both round-3 sequences, mixed progress, status). At f6cae4ba, the 4 round-4 cases fail. At 8aa9ab02, the 3 round-5 cases fail.
• Mutations, each killed:
  • result unit: tie goes to the archive, lookup not taken, errored/resolved membership not taken, resultIsError not taken;
  • no boolean OR; status/phase rank off, or replay always wins; no derived-task recompute; no resolved filter; active-name union; no key passed to the rank rule;
  • "longer string wins";
  • "replay wins";
  • no union;
  • no per-key merge;
  • plain replace.
• bootstrapHistoryDedupe.renderer.test.tsx: drives the real useIpcSubscriptions through the fake session feed. It checks two things:
  • one turn-T row after bootstrap-complete (before the fix: ['turn-T', 'turn-T']);
  • archived text survives an empty reopened copy.
• Limit: no recorded bootstrap-overlap sequence exists in the fixture corpus. The turn states are built from the event shapes the reviewer traced (a repeated turn_started/block_started with no deltas yet). Nothing here measures how often this happens.
• Gates: npx tsc -b + src/renderer/src/workspace/hook/ipc + src/renderer/src/session-runtime/semantic + src/renderer/src/features/feed + src/renderer/src/rendering on 39c712b6: 58 files, 419 tests.

🤖 Generated with Claude Code